report.html

args = (<cupy_tests.core_tests.test_ndarray_copy_and_view.TestArrayCopyAndView object at 0x7f280b7c9850>,)
kw = {}, cupy_result = (array([0, 1, 2], dtype=int8),), cupy_error = None
numpy_result = (array([0, 1, 1], dtype=int8),), numpy_error = None
cupy_numpy_result_ndarrays = [(array([0, 1, 2], dtype=int8), array([0, 1, 1], dtype=int8))]
cupy_r = array([0, 1, 2], dtype=int8), numpy_r = array([0, 1, 1], dtype=int8)
masks = [None]

@_wraps_partial_xp(impl, name, sp_name, scipy_name)
def test_func(*args, **kw):
# Run cupy and numpy
(
cupy_result, cupy_error,
numpy_result, numpy_error) = (
_call_func_numpy_cupy(
impl, args, kw, name, sp_name, scipy_name))
assert cupy_result is not None or cupy_error is not None
assert numpy_result is not None or numpy_error is not None

# Check errors raised
if cupy_error or numpy_error:
_check_cupy_numpy_error(cupy_error,
numpy_error,
accept_error=accept_error)
return

# Check returned arrays

if not isinstance(cupy_result, (tuple, list)):
cupy_result = cupy_result,
if not isinstance(numpy_result, (tuple, list)):
numpy_result = numpy_result,

assert len(cupy_result) == len(numpy_result)

# Check types
cupy_numpy_result_ndarrays = [
_convert_output_to_ndarray(
cupy_r, numpy_r, sp_name, check_sparse_format)
for cupy_r, numpy_r in zip(cupy_result, numpy_result)]

# Check dtypes
if type_check:
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
if cupy_r.dtype != numpy_r.dtype:
raise AssertionError(
'''ndarrays of different dtypes are returned.
cupy: {}
numpy: {}'''.format(cupy_r.dtype, numpy_r.dtype))

# Check contiguities
if contiguous_check:
for cupy_r, numpy_r in zip(cupy_result, numpy_result):
if isinstance(numpy_r, numpy.ndarray):
if (numpy_r.flags.c_contiguous
and not cupy_r.flags.c_contiguous):
raise AssertionError(
'The state of c_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.c_contiguous,
numpy_r.flags.c_contiguous))
if (numpy_r.flags.f_contiguous
and not cupy_r.flags.f_contiguous):
raise AssertionError(
'The state of f_contiguous flag is false. '
'(cupy_result:{} numpy_result:{})'.format(
cupy_r.flags.f_contiguous,
numpy_r.flags.f_contiguous))

# Check shapes
for cupy_r, numpy_r in cupy_numpy_result_ndarrays:
assert cupy_r.shape == numpy_r.shape

masks = [None] * len(cupy_result)
if _contains_signed_and_unsigned(kw):
needs_mask = [
cupy_r.dtype in _unsigned_dtypes
for cupy_r in cupy_result]
if any(needs_mask):
masks = _make_positive_masks(
impl, args, kw, name, sp_name, scipy_name)
for i, flag in enumerate(needs_mask):
if not flag:
masks[i] = None

# Check item values
for (cupy_r, numpy_r), mask in zip(
cupy_numpy_result_ndarrays, masks):
# Behavior of assigning a negative value to an unsigned integer
# variable is undefined.
# nVidia GPUs and Intel CPUs behave differently.
# To avoid this difference, we need to ignore dimensions whose
# values are negative.

skip = False
if mask is not None:
if cupy_r.shape == ():
skip = (mask == 0).all()
else:
cupy_r = cupy_r[mask].get()
numpy_r = numpy_r[mask]

if not skip:
> check_func(cupy_r, numpy_r)

cupy/testing/_helper.py:355:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:660: in check_func
_array.assert_array_equal(x, y, err_msg, verbose, strides_check)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

x = array([0, 1, 2], dtype=int8), y = array([0, 1, 1], dtype=int8), err_msg = ''
verbose = True, strides_check = False

def assert_array_equal(x, y, err_msg='', verbose=True, strides_check=False):
"""Raises an AssertionError if two array_like objects are not equal.

Args:
x(numpy.ndarray or cupy.ndarray): The actual object to check.
y(numpy.ndarray or cupy.ndarray): The desired, expected object.
strides_check(bool): If ``True``, consistency of strides is also
checked.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting values
are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_array_equal`
"""
> numpy.testing.assert_array_equal(
cupy.asnumpy(x), cupy.asnumpy(y), err_msg=err_msg,
verbose=verbose)
E AssertionError:
E Arrays are not equal
E
E Mismatched elements: 1 / 3 (33.3%)
E Max absolute difference: 1
E Max relative difference: 1.
E x: array([0, 1, 2], dtype=int8)
E y: array([0, 1, 1], dtype=int8)

cupy/testing/_array.py:91: AssertionError

self = <cupy_tests.core_tests.test_ndarray_elementwise_op.TestArrayElementwiseOp testMethod=test_add_array_boolarray>

def test_add_array_boolarray(self):
> self.check_array_boolarray_op(operator.add)

tests/cupy_tests/core_tests/test_ndarray_elementwise_op.py:478:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:837: in test_func
impl(*args, **kw)
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5., 8., 5.],
[263., 253., 255.]])
desired = array([[3., 8., 2.],
[9., 3., 9.]]), rtol = 1e-07, atol = 0
err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=0
E
E Mismatched elements: 5 / 6 (83.3%)
E Max absolute difference: 254.
E Max relative difference: 83.33333333
E x: array([[ 5., 8., 5.],
E [263., 253., 255.]])
E y: array([[3., 8., 2.],
E [9., 3., 9.]])

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
x_type is <class 'numpy.float64'>

self = <cupy_tests.core_tests.test_ndarray_elementwise_op.TestArrayElementwiseOp testMethod=test_iadd_array_boolarray>

def test_iadd_array_boolarray(self):
> self.check_array_boolarray_op(operator.iadd)

tests/cupy_tests/core_tests/test_ndarray_elementwise_op.py:481:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:837: in test_func
impl(*args, **kw)
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[ 5., 8., 5.],
[263., 253., 255.]])
desired = array([[3., 8., 2.],
[9., 3., 9.]]), rtol = 1e-07, atol = 0
err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=0
E
E Mismatched elements: 5 / 6 (83.3%)
E Max absolute difference: 254.
E Max relative difference: 83.33333333
E x: array([[ 5., 8., 5.],
E [263., 253., 255.]])
E y: array([[3., 8., 2.],
E [9., 3., 9.]])

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
x_type is <class 'numpy.float64'>

[XPASS(strict)] HIP/ROCm may have a bug with larger `b`

[XPASS(strict)] HIP/ROCm may have a bug with larger `b`

[XPASS(strict)] HIP/ROCm may have a bug with larger `b`

[XPASS(strict)] ROCm/HIP may have a bug

[XPASS(strict)] ROCm/HIP may have a bug

[XPASS(strict)] ROCm/HIP may have a bug

self = <cupyx_tests.jit_tests.test_raw.TestRaw testMethod=test_atomic_add>
dtype = <class 'numpy.float16'>

@testing.for_dtypes('iILQefd')
def test_atomic_add(self, dtype):
@jit.rawkernel()
def f(x, index, out):
tid = jit.blockDim.x * jit.blockIdx.x + jit.threadIdx.x
jit.atomic_add(out, index[tid], x[tid])

x = testing.shaped_random((1024,), dtype=dtype, seed=0)
index = testing.shaped_random(
(1024,), dtype=numpy.bool_, seed=1).astype(numpy.int32)
out = cupy.zeros((2,), dtype=dtype)
> f((32,), (32,), (x, index, out))

tests/cupyx_tests/jit_tests/test_raw.py:146:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupyx/jit/_interface.py:92: in __call__
result = _compile.transpile(
cupyx/jit/_compile.py:85: in transpile
cuda_code, env = _transpile_function(
cupyx/jit/_compile.py:175: in _transpile_function
exc.reraise(source)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = _JitCompileError(TypeError('`atomicAdd` does not support float16 input.'), <_ast.Call object at 0x7f1f436230d0>)
pycode = ' @jit.rawkernel()\n def f(x, index, out):\n tid = jit.blockDim.x * jit.blockIdx.x + jit.threadIdx.x\n> jit.atomic_add(out, index[tid], x[tid])\n'

def reraise(self, pycode):
start = self.node.lineno
end = getattr(self.node, 'end_lineno', start)
pycode = '\n'.join([
(f'> {line}' if start <= i + 1 <= end else f' {line}').rstrip()
for i, line in enumerate(pycode.split('\n'))])
> raise self.error_type(self.mes + '\n\n' + pycode)
E TypeError: `atomicAdd` does not support float16 input.
E
E @jit.rawkernel()
E def f(x, index, out):
E tid = jit.blockDim.x * jit.blockIdx.x + jit.threadIdx.x
E > jit.atomic_add(out, index[tid], x[tid])

cupyx/jit/_compile.py:42: TypeError
------------------------------Captured stdout call------------------------------
dtype is e

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestMapCoordinatesHalfInteger object at 0x7f1ee6877100> parameter: {'mode': 'grid-constant', 'order': 4}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([229.76997843, 598.96953239])
desired = array([3.06993892, 8. ]), rtol = 1e-07, atol = 0.0001
err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=0.0001
E
E Mismatched elements: 2 / 2 (100%)
E Max absolute difference: 590.96953239
E Max relative difference: 73.87119155
E x: array([229.769978, 598.969532])
E y: array([3.069939, 8. ])

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestMapCoordinatesHalfInteger object at 0x7f1ee6884430> parameter: {'mode': 'grid-constant', 'order': 5}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([ 78.42728447, 201.97560613])
desired = array([3.12122783, 8. ]), rtol = 1e-07, atol = 0.0001
err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=0.0001
E
E Mismatched elements: 2 / 2 (100%)
E Max absolute difference: 193.97560613
E Max relative difference: 24.24695077
E x: array([ 78.427284, 201.975606])
E y: array([3.121228, 8. ])

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddf22280> parameter: {'grid_mode': False, 'mode': 'constant', 'order': 4, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-9.26215027e-04],
[-7.12910551e-05],
[-1.04548770e-03],
[ 6.02170185e-04],
[ ... [-1.58413204e-05],
[-2.26292832e-05],
[-1.52809316e-05],
[-2.62873400e-05]]], dtype=float32)
desired = array([[[-1.91677706e-16],
[ 6.02007280e-16],
[ 7.39644969e-18],
[ 9.42839520e-17],
[-... [ 2.49078413e-18],
[-6.86374620e-18],
[-2.01807717e-17],
[-1.36889723e-17]]], dtype=float32)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 95 / 100 (95%)
E Max absolute difference: 0.00124037
E Max relative difference: 1.6367563e+14
E x: array([[[-9.262150e-04],
E [-7.129106e-05],
E [-1.045488e-03],...
E y: array([[[-1.916777e-16],
E [ 6.020073e-16],
E [ 7.396450e-18],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddbbb700> parameter: {'grid_mode': False, 'mode': 'constant', 'order': 5, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-6.23873319e-04],
[-6.52701594e-04],
[-5.34185849e-04],
[-7.05319864e-04],
[-... [-2.50156190e-05],
[ 9.55036171e-07],
[-1.27298597e-06],
[-4.17136789e-06]]], dtype=float32)
desired = array([[[ 2.1000416e-16],
[-7.7505151e-16],
[-6.6172874e-17],
[-6.5140899e-16],
[ 7.95... [-1.5922411e-17],
[ 3.1236140e-17],
[-5.3157008e-17],
[-1.3124647e-17]]], dtype=float32)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 85 / 100 (85%)
E Max absolute difference: 0.00084527
E Max relative difference: 1.881553e+13
E x: array([[[-6.238733e-04],
E [-6.527016e-04],
E [-5.341858e-04],...
E y: array([[[ 2.100042e-16],
E [-7.750515e-16],
E [-6.617287e-17],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddbc8fd0> parameter: {'grid_mode': False, 'mode': 'mirror', 'order': 4, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-9.26215027e-04],
[-7.12910551e-05],
[-1.04548770e-03],
[ 6.02170185e-04],
[ ... [-1.58413204e-05],
[-2.26292832e-05],
[-1.52809316e-05],
[-2.62873400e-05]]], dtype=float32)
desired = array([[[-1.91677706e-16],
[ 6.02007280e-16],
[ 7.39644969e-18],
[ 9.42839520e-17],
[-... [ 2.49078413e-18],
[-6.86374620e-18],
[-2.01807717e-17],
[-1.36889723e-17]]], dtype=float32)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 95 / 100 (95%)
E Max absolute difference: 0.00124037
E Max relative difference: 1.6367563e+14
E x: array([[[-9.262150e-04],
E [-7.129106e-05],
E [-1.045488e-03],...
E y: array([[[-1.916777e-16],
E [ 6.020073e-16],
E [ 7.396450e-18],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddbbb100> parameter: {'grid_mode': False, 'mode': 'mirror', 'order': 5, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-6.23873319e-04],
[-6.52701594e-04],
[-5.34185849e-04],
[-7.05319864e-04],
[-... [-2.50156190e-05],
[ 9.55036171e-07],
[-1.27298597e-06],
[-4.17136789e-06]]], dtype=float32)
desired = array([[[ 2.1000416e-16],
[-7.7505151e-16],
[-6.6172874e-17],
[-6.5140899e-16],
[ 7.95... [-1.5922411e-17],
[ 3.1236140e-17],
[-5.3157008e-17],
[-1.3124647e-17]]], dtype=float32)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 85 / 100 (85%)
E Max absolute difference: 0.00084527
E Max relative difference: 1.881553e+13
E x: array([[[-6.238733e-04],
E [-6.527016e-04],
E [-5.341858e-04],...
E y: array([[[ 2.100042e-16],
E [-7.750515e-16],
E [-6.617287e-17],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1edd8ef580> parameter: {'grid_mode': False, 'mode': 'wrap', 'order': 4, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-9.26215027e-04],
[-7.12910551e-05],
[-1.04548770e-03],
[ 6.02170185e-04],
[ ... [-1.58413204e-05],
[-2.26292832e-05],
[-1.52809316e-05],
[-2.62873400e-05]]], dtype=float32)
desired = array([[[-1.91677706e-16],
[ 6.02007280e-16],
[ 7.39644969e-18],
[ 9.42839520e-17],
[-... [ 2.49078413e-18],
[-6.86374620e-18],
[-2.01807717e-17],
[-1.36889723e-17]]], dtype=float32)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 95 / 100 (95%)
E Max absolute difference: 0.00124037
E Max relative difference: 1.6367563e+14
E x: array([[[-9.262150e-04],
E [-7.129106e-05],
E [-1.045488e-03],...
E y: array([[[-1.916777e-16],
E [ 6.020073e-16],
E [ 7.396450e-18],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1edd87eb20> parameter: {'grid_mode': False, 'mode': 'wrap', 'order': 5, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-6.23873319e-04],
[-6.52701594e-04],
[-5.34185849e-04],
[-7.05319864e-04],
[-... [-2.50156190e-05],
[ 9.55036171e-07],
[-1.27298597e-06],
[-4.17136789e-06]]], dtype=float32)
desired = array([[[ 2.1000416e-16],
[-7.7505151e-16],
[-6.6172874e-17],
[-6.5140899e-16],
[ 7.95... [-1.5922411e-17],
[ 3.1236140e-17],
[-5.3157008e-17],
[-1.3124647e-17]]], dtype=float32)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 85 / 100 (85%)
E Max absolute difference: 0.00084527
E Max relative difference: 1.881553e+13
E x: array([[[-6.238733e-04],
E [-6.527016e-04],
E [-5.341858e-04],...
E y: array([[[ 2.100042e-16],
E [-7.750515e-16],
E [-6.617287e-17],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1edd903430> parameter: {'grid_mode': False, 'mode': 'grid-constant', 'order': 4, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-1.6466675e-04],
[-3.1765160e-06],
[-2.8256103e-04],
[ 1.0465207e-04],
[-5.02... [-1.4928388e-06],
[-5.8970027e-06],
[-2.4932410e-06],
[-3.5395026e-06]]], dtype=float32)
desired = array([[[-8.12850668e-17],
[-9.62678620e-17],
[-7.64445911e-17],
[ 6.90388762e-17],
[-... [-1.31306278e-18],
[-2.34584224e-18],
[-1.16198641e-18],
[-3.16820747e-19]]], dtype=float32)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 75 / 100 (75%)
E Max absolute difference: 0.00034115
E Max relative difference: 2.5044335e+14
E x: array([[[-1.646668e-04],
E [-3.176516e-06],
E [-2.825610e-04],...
E y: array([[[-8.128507e-17],
E [-9.626786e-17],
E [-7.644459e-17],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1edd87e550> parameter: {'grid_mode': False, 'mode': 'grid-constant', 'order': 5, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 1.46576144e-06],
[-1.07652804e-05],
[ 1.48250510e-05],
[-2.88788979e-05],
[-... [ 3.59045725e-06],
[ 3.90473633e-06],
[ 2.02454498e-06],
[ 1.08106917e-06]]], dtype=float32)
desired = array([[[-5.28892732e-17],
[-4.68497761e-17],
[-1.70810335e-16],
[-1.91986781e-16],
[-... [-3.94138989e-18],
[-8.65396191e-18],
[ 1.07858407e-18],
[-2.29544853e-18]]], dtype=float32)
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 40 / 100 (40%)
E Max absolute difference: 0.00011814
E Max relative difference: 9.6834375e+13
E x: array([[[ 1.465761e-06],
E [-1.076528e-05],
E [ 1.482505e-05],...
E y: array([[[-5.288927e-17],
E [-4.684978e-17],
E [-1.708103e-16],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddbb2160> parameter: {'grid_mode': True, 'mode': 'constant', 'order': 4, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 0. ],
[ 0. ],
[ 0. ],
[ 0. ],
[ 0. ... [ 0. ],
[ 0. ],
[ 0. ],
[ 0. ],
[ 0. ]]])
desired = array([[[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ ...000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00]]])
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 64 / 100 (64%)
E Max absolute difference: 2336.52632552
E Max relative difference: 629887.8879561
E x: array([[[ 0. ],
E [ 0. ],
E [ 0. ],...
E y: array([[[ 0.000000e+00],
E [ 0.000000e+00],
E [ 0.000000e+00],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddb510d0> parameter: {'grid_mode': True, 'mode': 'constant', 'order': 5, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ ...000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00]]])
desired = array([[[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ ...000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00],
[ 0.00000000e+00]]])
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 64 / 100 (64%)
E Max absolute difference: 233.83963068
E Max relative difference: 148867.79248851
E x: array([[[ 0.000000e+00],
E [ 0.000000e+00],
E [ 0.000000e+00],...
E y: array([[[ 0.000000e+00],
E [ 0.000000e+00],
E [ 0.000000e+00],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddbd9a60> parameter: {'grid_mode': True, 'mode': 'mirror', 'order': 4, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 48.82195577],
[ 48.82195577],
[ 290.39318135],
[ 337.78017528],
[ 112.1240... [ -53.24969236],
[ -21.88859247],
[ 44.15090669],
[ 53.29762289],
[ 53.29762289]]])
desired = array([[[ 8.54663183e-03],
[ 8.54663183e-03],
[ 5.30645857e-02],
[ 6.15797757e-02],
[ ...126e-03],
[-5.57818230e-04],
[ 2.89445841e-04],
[ 8.46143247e-05],
[ 8.46143247e-05]]])
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 100 / 100 (100%)
E Max absolute difference: 2336.52632552
E Max relative difference: 629887.88795612
E x: array([[[ 48.821956],
E [ 48.821956],
E [ 290.393181],...
E y: array([[[ 8.546632e-03],
E [ 8.546632e-03],
E [ 5.306459e-02],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1edd872730> parameter: {'grid_mode': True, 'mode': 'mirror', 'order': 5, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 4.71685805e+00],
[ 4.71685805e+00],
[ 2.76221015e+01],
[ 3.32433453e+01],
[ ...958e+00],
[-1.62349834e+00],
[ 1.50933488e+01],
[ 1.97919669e+01],
[ 1.97919669e+01]]])
desired = array([[[ 8.60075856e-03],
[ 8.60075856e-03],
[ 5.25533883e-02],
[ 6.23449044e-02],
[ ...600e-03],
[-8.00397905e-04],
[ 4.16976616e-04],
[ 1.32949066e-04],
[ 1.32949066e-04]]])
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 100 / 100 (100%)
E Max absolute difference: 233.83963068
E Max relative difference: 148867.79248854
E x: array([[[ 4.716858e+00],
E [ 4.716858e+00],
E [ 2.762210e+01],...
E y: array([[[ 8.600759e-03],
E [ 8.600759e-03],
E [ 5.255339e-02],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1edd8e61f0> parameter: {'grid_mode': True, 'mode': 'wrap', 'order': 4, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 53.29762289],
[ 51.0107262 ],
[ 303.41199632],
[ 352.92342892],
[ 117.1507... [ -50.96485228],
[ -20.9493958 ],
[ 42.25647769],
[ 51.0107262 ],
[ 48.82195577]]])
desired = array([[[ 8.46143247e-05],
[ 8.50392545e-04],
[ 5.27994291e-03],
[ 6.12720698e-03],
[ ...636e-02],
[-5.60619571e-03],
[ 2.90899427e-03],
[ 8.50392545e-04],
[ 8.54663183e-03]]])
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 100 / 100 (100%)
E Max absolute difference: 2336.52632552
E Max relative difference: 629887.8879561
E x: array([[[ 53.297623],
E [ 51.010726],
E [ 303.411996],...
E y: array([[[ 8.461432e-05],
E [ 8.503925e-04],
E [ 5.279943e-03],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1edd25e490> parameter: {'grid_mode': True, 'mode': 'wrap', 'order': 5, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 1.97919669e+01],
[ 9.66208561e+00],
[ 5.65815436e+01],
[ 6.80961870e+01],
[ ...577e+00],
[-7.92562963e-01],
[ 7.36830399e+00],
[ 9.66208561e+00],
[ 4.71685805e+00]]])
desired = array([[[ 1.32949066e-04],
[ 1.06932821e-03],
[ 6.53393769e-03],
[ 7.75131221e-03],
[ ...718e-02],
[-6.43771396e-03],
[ 3.35380211e-03],
[ 1.06932821e-03],
[ 8.60075856e-03]]])
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 100 / 100 (100%)
E Max absolute difference: 233.83963068
E Max relative difference: 148867.79248851
E x: array([[[ 1.979197e+01],
E [ 9.662086e+00],
E [ 5.658154e+01],...
E y: array([[[ 1.329491e-04],
E [ 1.069328e-03],
E [ 6.533938e-03],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddbf18e0> parameter: {'grid_mode': True, 'mode': 'grid-constant', 'order': 4, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 5.63055219e+01],
[-1.22528405e+02],
[-3.83476709e+02],
[-3.83476709e+02],
[-...021e+00],
[ 4.40535983e+00],
[-2.69124172e+00],
[-1.59183812e+00],
[ 9.72456581e-01]]])
desired = array([[[ 1.27949283e-02],
[-2.43606830e-02],
[-7.91692940e-02],
[-7.91692940e-02],
[-...333e-03],
[ 9.13158865e-04],
[-5.54269262e-04],
[-3.27391850e-04],
[ 1.99955080e-04]]])
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 100 / 100 (100%)
E Max absolute difference: 2611.23242921
E Max relative difference: 5747.85704324
E x: array([[[ 5.630552e+01],
E [-1.225284e+02],
E [-3.834767e+02],...
E y: array([[[ 1.279493e-02],
E [-2.436068e-02],
E [-7.916929e-02],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<cupyx_tests.scipy_tests.ndimage_tests.test_interpolation.TestZoomOutputSize1 object at 0x7f1eddb51e80> parameter: {'grid_mode': True, 'mode': 'grid-constant', 'order': 5, 'shape': (5, 5, 2), 'zoom': (2, 2, 0.5)}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 4.16965077e+00],
[-1.18699209e+01],
[-3.36177788e+01],
[-3.36177788e+01],
[-...671e-01],
[ 6.07624141e-01],
[-3.96545295e-01],
[-2.61764771e-01],
[ 1.70742628e-01]]])
desired = array([[[ 1.44354197e-02],
[-2.67893098e-02],
[-8.45564959e-02],
[-8.45564959e-02],
[-...699e-03],
[ 1.49724992e-03],
[-9.55056276e-04],
[-6.25982935e-04],
[ 4.07383783e-04]]])
rtol = 1e-07, atol = 1e-05, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-07, atol=1e-05
E
E Mismatched elements: 100 / 100 (100%)
E Max absolute difference: 270.54779997
E Max relative difference: 678.67662434
E x: array([[[ 4.169651e+00],
E [-1.186992e+01],
E [-3.361778e+01],...
E y: array([[[ 1.443542e-02],
E [-2.678931e-02],
E [-8.455650e-02],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<test_signaltools.TestFFTConvolve object at 0x7f1ecffa4fa0> parameter: {'mode': 'full', 'size1': (3, 4, 10), 'size2': 3}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 7.95232463e+01, 7.18281100e+01, -1.08830701e+01,
-2.99679584e+01, -3.25484953e+01, 1.26672720e+01... -7.54439194e+02, -5.21641607e+02, -8.12674000e+02,
-6.47990876e+02, -5.10732530e+02, -3.22703181e+02]]])
desired = array([[[ 30.11962621, 78.50111643, 117.31051907, 116.12191629,
98.55258208, 98.59044458, 95.74539693, 11...68602809, 61.03013855, 47.46049262, 68.94265745,
60.25645139, 72.94771467, 56.95651852, 9.92766801]]])
rtol = 1e-08, atol = 1e-08, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-08, atol=1e-08
E
E Mismatched elements: 360 / 360 (100%)
E Max absolute difference: 2190.14702549
E Max relative difference: 51.28040502
E x: array([[[ 7.952325e+01, 7.182811e+01, -1.088307e+01, -2.996796e+01,
E -3.254850e+01, 1.266727e+01, -1.785286e+01, 3.703741e+01,
E 4.268585e+01, -9.254362e+01, -1.219189e+02, -3.967023e+01],...
E y: array([[[ 30.119626, 78.501116, 117.310519, 116.121916, 98.552582,
E 98.590445, 95.745397, 119.16961 , 143.041925, 143.716735,
E 85.509392, 23.11245 ],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<test_signaltools.TestFFTConvolve object at 0x7f1ecf314af0> parameter: {'mode': 'valid', 'size1': (3, 4, 10), 'size2': 3}>,)
kw = {'dtype': <class 'numpy.float16'>}, dtype = <class 'numpy.float16'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-41138.582 , 19940.28 , -28182.572 , -13121.586 ,
5010.394 , 22920.586 , 935.27344, ... , -17812.22 , 36488.453 ,
-46610.863 , -20180.379 , -39984.668 , -5373.056 ]]],
dtype=float32)
desired = array([[[800.56824, 863.0409 , 683.2234 , 644.73334, 573.70703,
714.93976, 728.83124, 808.6099 ],
[879.7528 , 920.53406, 785.268 , 688.99976, 587.2948 ,
719.44885, 815.8003 , 851.3048 ]]], dtype=float32)
rtol = 0.001, atol = 0.001, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=0.001, atol=0.001
E
E Mismatched elements: 16 / 16 (100%)
E Max absolute difference: 47198.156
E Max relative difference: 80.36536
E x: array([[[-41138.582 , 19940.28 , -28182.572 , -13121.586 ,
E 5010.394 , 22920.586 , 935.27344, 2970.8938 ],
E [ 6094.4087 , 35791.06 , -17812.22 , 36488.453 ,...
E y: array([[[800.56824, 863.0409 , 683.2234 , 644.73334, 573.70703,
E 714.93976, 728.83124, 808.6099 ],
E [879.7528 , 920.53406, 785.268 , 688.99976, 587.2948 ,
E 719.44885, 815.8003 , 851.3048 ]]], dtype=float32)

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float16'>

args = (<<test_signaltools.TestFFTConvolve object at 0x7f1ecf28a5e0> parameter: {'mode': 'full', 'size1': (3, 4, 10), 'size2': 3}>,)
kw = {'dtype': <class 'numpy.float64'>}, dtype = <class 'numpy.float64'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ 7.95232463e+01, 7.18281100e+01, -1.08830701e+01,
-2.99679584e+01, -3.25484953e+01, 1.26672720e+01... -7.54439194e+02, -5.21641607e+02, -8.12674000e+02,
-6.47990876e+02, -5.10732530e+02, -3.22703181e+02]]])
desired = array([[[ 30.11962621, 78.50111643, 117.31051907, 116.12191629,
98.55258208, 98.59044458, 95.74539693, 11...68602809, 61.03013855, 47.46049262, 68.94265745,
60.25645139, 72.94771467, 56.95651852, 9.92766801]]])
rtol = 1e-08, atol = 1e-08, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-08, atol=1e-08
E
E Mismatched elements: 360 / 360 (100%)
E Max absolute difference: 2190.14702549
E Max relative difference: 51.28040502
E x: array([[[ 7.952325e+01, 7.182811e+01, -1.088307e+01, -2.996796e+01,
E -3.254850e+01, 1.266727e+01, -1.785286e+01, 3.703741e+01,
E 4.268585e+01, -9.254362e+01, -1.219189e+02, -3.967023e+01],...
E y: array([[[ 30.119626, 78.501116, 117.310519, 116.121916, 98.552582,
E 98.590445, 95.745397, 119.16961 , 143.041925, 143.716735,
E 85.509392, 23.11245 ],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float64'>

args = (<<test_signaltools.TestFFTConvolve object at 0x7f1ecf109190> parameter: {'mode': 'valid', 'size1': (3, 4, 10), 'size2': 3}>,)
kw = {'dtype': <class 'numpy.float16'>}, dtype = <class 'numpy.float16'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
cupy/testing/_array.py:24: in assert_allclose
numpy.testing.assert_allclose(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

x = array([[[ 21340., inf, -51680., -inf, inf, 49500., -inf,
inf],
[ inf, -inf, -45600., inf, -inf, -inf, -inf,
inf]]], dtype=float16)
y = array([[[800.5, 863. , 683. , 644.5, 573.5, 715. , 729. , 808.5],
[880. , 920.5, 785.5, 689. , 587.5, 719.5, 816. , 851.5]]],
dtype=float16)
func = <function assert_array_compare.<locals>.<lambda> at 0x7f1ecf3539d0>
hasval = '+inf'

def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
"""Handling nan/inf.

Combine results of running func on x and y, checking that they are True
at the same locations.

"""
x_id = func(x)
y_id = func(y)
# We include work-arounds here to handle three types of slightly
# pathological ndarray subclasses:
# (1) all() on `masked` array scalars can return masked arrays, so we
# use != True
# (2) __eq__ on some ndarray subclasses returns Python booleans
# instead of element-wise comparisons, so we cast to bool_() and
# use isinstance(..., bool) checks
# (3) subclasses with bare-bones __array_function__ implementations may
# not implement np.all(), so favor using the .all() method
# We are not committed to supporting such subclasses, but it's nice to
# support them if possible.
if bool_(x_id == y_id).all() != True:
msg = build_err_msg([x, y],
err_msg + '\nx and y %s location mismatch:'
% (hasval), verbose=verbose, header=header,
names=('x', 'y'), precision=precision)
> raise AssertionError(msg)
E AssertionError:
E Not equal to tolerance rtol=0.001, atol=0.001
E
E x and y +inf location mismatch:
E x: array([[[ 21340., inf, -51680., -inf, inf, 49500., -inf,
E inf],
E [ inf, -inf, -45600., inf, -inf, -inf, -inf,
E inf]]], dtype=float16)
E y: array([[[800.5, 863. , 683. , 644.5, 573.5, 715. , 729. , 808.5],
E [880. , 920.5, 785.5, 689. , 587.5, 719.5, 816. , 851.5]]],
E dtype=float16)

/home/kmaeh/.pyenv/versions/rocm-ci/lib/python3.8/site-packages/numpy/testing/_private/utils.py:740: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float16'>

args = (<<test_signaltools.TestFFTConvolve object at 0x7f1ecf109910> parameter: {'mode': 'full', 'size1': (3, 4, 10), 'size2': 3}>,)
kw = {'dtype': <class 'numpy.float32'>}, dtype = <class 'numpy.float32'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[ -67.023415 , -34.65665 , 2.4082286 , 4.3990808 ,
30.086672 , -31.448004 , -59.45321...1.743105 , 4.0651803 ,
-59.686687 , -25.86646 , -49.65274 , -31.778236 ]]],
dtype=float32)
desired = array([[[ 7.8674293, 45.3722 , 60.898335 , 54.842022 ,
48.07059 , 42.814228 , 52.615826 , 48.42525...42563 , 126.12969 , 119.81335 ,
143.07594 , 136.70508 , 97.919945 , 38.007053 ]]],
dtype=float32)
rtol = 0.001, atol = 0.001, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=0.001, atol=0.001
E
E Mismatched elements: 360 / 360 (100%)
E Max absolute difference: 750.6533
E Max relative difference: 10.774607
E x: array([[[ -67.023415, -34.65665 , 2.408229, 4.399081,
E 30.086672, -31.448004, -59.453213, -71.971054,
E -90.94983 , -76.126305, -63.273407, -44.329117],...
E y: array([[[ 7.867429, 45.3722 , 60.898335, 54.842022, 48.07059 ,
E 42.814228, 52.615826, 48.42525 , 76.05639 , 77.71094 ,
E 35.934895, 4.535131],...

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.float32'>

args = (<<test_signaltools.TestFFTConvolve object at 0x7f1ecf31cd90> parameter: {'mode': 'valid', 'size1': (3, 4, 10), 'size2': 3}>,)
kw = {'dtype': <class 'numpy.longlong'>}, dtype = <class 'numpy.longlong'>

@_wraps_partial(impl, name)
def test_func(*args, **kw):
for dtype in dtypes:
try:
kw[name] = numpy.dtype(dtype).type
> impl(*args, **kw)

cupy/testing/_helper.py:837:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
cupy/testing/_helper.py:355: in test_func
check_func(cupy_r, numpy_r)
cupy/testing/_helper.py:507: in check_func
_array.assert_allclose(c, n, rtol1, atol1, err_msg, verbose)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

actual = array([[[-9223372034952392704, 9223372036489740288,
-9223372034401665024, 9223372036581769216,
-92... -8323010019634937856, 9223372034681276416,
9223372033914114048, -9223372034838167552]]], dtype=int64)
desired = array([[[629, 722, 546, 533, 486, 484, 673, 613],
[706, 763, 543, 463, 398, 605, 652, 729]]], dtype=int64)
rtol = 1e-08, atol = 1e-08, err_msg = '', verbose = True

def assert_allclose(actual, desired, rtol=1e-7, atol=0, err_msg='',
verbose=True):
"""Raises an AssertionError if objects are not equal up to desired tolerance.

Args:
actual(numpy.ndarray or cupy.ndarray): The actual object to check.
desired(numpy.ndarray or cupy.ndarray): The desired, expected object.
rtol(float): Relative tolerance.
atol(float): Absolute tolerance.
err_msg(str): The error message to be printed in case of failure.
verbose(bool): If ``True``, the conflicting
values are appended to the error message.

.. seealso:: :func:`numpy.testing.assert_allclose`

""" # NOQA
> numpy.testing.assert_allclose(
cupy.asnumpy(actual), cupy.asnumpy(desired),
rtol=rtol, atol=atol, err_msg=err_msg, verbose=verbose)
E AssertionError:
E Not equal to tolerance rtol=1e-08, atol=1e-08
E
E Mismatched elements: 16 / 16 (100%)
E Max absolute difference: 9223372036581768683
E Max relative difference: 2.09120855e+16
E x: array([[[-9223372034952392704, 9223372036489740288,
E -9223372034401665024, 9223372036581769216,
E -9223372034839863296, 9223372033767677952,...
E y: array([[[629, 722, 546, 533, 486, 484, 673, 613],
E [706, 763, 543, 463, 398, 605, 652, 729]]], dtype=int64)

cupy/testing/_array.py:24: AssertionError
------------------------------Captured stdout call------------------------------
dtype is <class 'numpy.longlong'>